Fork me on GitHub

Vue.js 笔记

发表于 | 分类于 ， | 热度: °C
字数统计: 3,080 | 阅读时长 ≈ 13

前言：

  1. Vue.js 笔记；

Vue.js 简介

1. Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架。
    与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。
    Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。
    另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。
    
2. 前端三大新框架：Angular.js、React.js、Vue.js

Vue.js 使用文档及下载

  1. 使用文档： https://cn.vuejs.org/v2/guide/
  2. 下载地址： https://cn.vuejs.org/v2/guide/installation.html
引入 Vue：
    <!-- 开发环境版本，包含了有帮助的命令行警告 -->
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    
    <!-- 生产环境版本，优化了尺寸和速度 -->
    <script src="https://cdn.jsdelivr.net/npm/vue"></script>

Vue 实例

虽然没有完全遵循 MVVM 模型，但是 Vue 的设计也受到了它的启发。
因此在文档中经常会使用 vm (ViewModel 的缩写) 这个变量名表示 Vue 实例。

    window.onload = function(){
        var vm = new Vue(){
            // 绑定 id，通常绑 div 上，不能绑 body
            el: '#app',
            // 自定义属性：里面是定义数据的，如果要输出数据，就要在 html 中去输出
            data: {
				message: 'hello vue!'
            }
        }
    }
    ......
    <!--使用 Vue 的准备工作，准备一个 div 标签，并且该标签有一个 id-->
    <div id="app">{{ message }}</div>

模板语法

window.onload = function(){
    var vm = new Vue({
		el: '#app',
		data: {
			num: 1023,
			num2: 1024,
			message: 'hello vue!',
			ok: true,
			baidu: 'http://www.baidu.com',
			title: '百度一下，你就知道',
			rawHtml: '<span style="color: red">This should be red.</span>'
		}
	})
}
	
1. 插值

    # 文本
    
        数据绑定最常见的形式就是使用“Mustache”语法 (双大括号) 的文本插值：
    
        <span>Message: {{ message }}</span>
      
    # 原始 HTML
        
        双大括号会将数据解释为普通文本，而非 HTML 代码。为了输出真正的 HTML，你需要使用 v-html 指令：
    
        <p>Using mustaches: {{ rawHtml }}</p>
        <p>Using v-html directive: <span v-html="rawHtml"></span></p>
    
    # 特性
        如果是标签的属性要使用值，就不能使用“Mustache”语法，需要写成使用v-bind指令：
        
        <a v-bind:href="url" v-bind:title='tip'>百度网</a>
    
    # 使用 JavaScript 表达式
        
        {{ number + 1 }}
        {{ ok ? 'YES' : 'NO' }} // 三元运算符
        {{ message.split('').reverse().join('') }}
        
2. 指令

    指令 (Directives) 是带有“v-”前缀的特殊属性。
    指令属性的值预期是单个 JavaScript 表达式，指令的职责是，当表达式的值改变时，将其产生的连带影响，响应式地作用于 DOM。
    常见的指令有 v-bind、v-if、v-on。
    
        <!-- 根据 ok 的布尔值来插入/移除 <p> 元素 -->
        <p v-if="ok">是否显示这一段</p>

    # 参数
    
        <!-- HTML属性，如果没绑定就原样输出。绑定之后才会调用 data 里面的属性
            在这里 href 是参数，告知 v-bind 指令将该元素的 href 特性与表达式 url 的值绑定 -->
        <a v-bind:href="url">...</a>
        
        <!-- 点击事件。vue 中的事件都是写在标签中
            监听按钮的 click 事件来执行 fnChangeMsg 方法 -->
        <button v-on:click="fnChangeMsg">按钮</button>
        
    # 修饰符
    
        修饰符 (Modifiers) 是以半角句号 . 指明的特殊后缀，用于指出一个指令应该以特殊方式绑定。
        例如，.prevent 修饰符告诉 v-on 指令对于触发的事件调用 event.preventDefault()：

        <form v-on:submit.prevent="onSubmit">...</form>

3. 缩写

    v-bind 和 v-on 事件这两个指令会经常用，所以有简写方式：
    
    # v-bind 缩写
        <!-- 完整语法 -->
        <a v-bind:href="url">...</a>
        
        <!-- 缩写 -->
        <a :href="url">...</a>
    
    # v-on 缩写
        <!-- 完整语法 -->
        <button v-on:click="fnChangeMsg">按钮</button>
        
        <!-- 缩写 -->
        <button @click="fnChangeMsg">按钮</button>

绑定 HTML Class

   var vm = new Vue({
	el:'#app',
	data:{
		ok1:false,
		ok2:true,
		classObject: {
               active: true,
               'text-danger': false
           }
	}
})
......
<div id="app">
	<!--
		1. 如果判断布尔值就用对象写法 (切换 class)
		2. 如果不是布尔值就用数组的写法 (class 列表)
	-->
	<!-- 1. 对象的语法。只能判断布尔值 -->
	<!--
		:class="{类名:判断的值,类名:判断的值}"
	-->
	<h1 :class="{red:ok1,font50:ok2}">文字文字</h1>
	
	<!-- 也可以给 v-bind:class 传一个对象引用 -->
	<div v-bind:class="classObject"></div>
	
	<!-- 2. 数组的语法。里面就是一个三元的判断 -->
	<h1 :class="[ok1?'red':'',ok2?'font50':'']">文字文字</h1>
</div>

条件渲染

通过条件指令可以控制元素的创建(显示)或者销毁(隐藏)，常用的条件指令如下：

v-if

v-if 可以控制元素的创建或者销毁

v-if=”判断的条件”

使用条件渲染注意：判断体的中间，不能有其他元素出现

<h1 v-if="ok">Yes</h1>

v-else

v-else 指令来表示 v-if 的“else 块”，v-else 元素必须紧跟在带 v-if 或者 v-else-if 的元素的后面，否则它将不会被识别。

<div v-if="Math.random() > 0.5">
  Now you see me
</div>
<div v-else>
  Now you don't
</div>

v-else-if

v-else-if，顾名思义，充当 v-if 的“else-if 块”，可以连续使用：

<div v-if="type === 'A'">
    A
</div>
<div v-else-if="type === 'B'">
    B
</div>
<div v-else-if="type === 'C'">
    C
</div>
<div v-else>
    Not A/B/C
</div>

v-show

另一个用于根据条件展示元素的选项是 v-show 指令。
用法和 v-if 大致一样，但是它不支持 v-else，
它和 v-if 的区别是，它制作元素样式的显示和隐藏，元素一直是存在的：

<h1 v-show="ok">Hello!</h1>

列表渲染

通过 v-for 指令可以将一组数据渲染到页面中，数据可以是数组或者对象，
v-for 指令需要使用 item in items 形式的特殊语法，items 是源数据数组并且 item 是数组元素迭代的别名。

1. 遍历数组

        <ul id="example-1">
          <li v-for="item in items">
            {{ item }}
          </li>
        </ul>
    
    vue 对象创建如下：
    
        var example1 = new Vue({
          el: '#example-1',
          data: {
            items: ['foo','bar']
          }
        })
    
    如果想加上索引值，可以加上第二个参数
    
        <ul id="example-2">
          <li v-for="(item, index) in items">
            {{ index }} - {{ item.message }}
          </li>
        </ul>

2. 遍历对象

    也可以用 v-for 通过一个对象的属性来迭代

        <ul id="v-for-object">
          <li v-for="value in object">
            {{ value }}
          </li>
        </ul>
    
    如果想加上对象属性名，可以加上第二个参数
    
        <ul id="v-for-object">
          <li v-for="(value,key) in object">
            {{ key }}-{{ value }}
          </li>
        </ul>

事件处理

事件绑定方法

可以用 v-on 指令监听 DOM 事件，并在触发时运行一些 JavaScript 代码，事件的处理，简单的逻辑可以写在指令中，复杂的需要在 vue 对象的 methods 属性中指定处理函数。

<div id="example-1">
  <!-- 在指令中写处理逻辑 -->
  <button v-on:click="counter += 1">Add 1</button>
  <p>The button above has been clicked {{ counter }} times.</p>
</div>
......
var example1 = new Vue({
  el: '#example-1',
  data: {
    counter: 0
  }
})

methods 属性中指定处理函数：

<div id="example-2">
  <!-- greet 是在下面定义的方法名 -->
  <button v-on:click="greet">Greet</button>
</div>
......

var example2 = new Vue({
  el: '#example-2',
  data: {
    name: 'Vue.js'
  },
  // 在 `methods` 对象中定义方法
  methods: {
    greet: function () {
      // `this` 在方法里指向当前 Vue 实例
      alert('Hello ' + this.name + '!')
    }
  }
})
事件修饰符

实际开发中，事件绑定有时候牵涉到阻止事件冒泡以及阻止默认行为，在 vue.js 可以加上事件修饰符

<!-- 阻止单击事件继续传播 -->
<a v-on:click.stop="doThis"></a>

<!-- 提交事件不再重载页面 -->
<form v-on:submit.prevent="onSubmit"></form>

<!-- 修饰符可以串联 -->
<a v-on:click.stop.prevent="doThat"></a>

<!-- 只有修饰符 -->
<form v-on:submit.prevent></form>

表单输入绑定

可以用 v-model 指令在表单 <input> 及 <textarea> 元素上创建 双向数据绑定。它会根据控件类型自动选取正确的方法来更新元素

单行文本框
<input v-model="message" placeholder="edit me">
<p>Message is: {{ message }}</p>
多行文本框
<span>Multiline message is:</span>
<p>{{ message }}</p>
<textarea v-model="message" placeholder="add multiple lines"></textarea>
复选框

单个复选框，绑定到布尔值：

<input type="checkbox" id="checkbox" v-model="checked">
<label for="checkbox">{{ checked }}</label>

多个复选框，绑定到同一个数组：

<div id='example-3'>
  <input type="checkbox" id="jack" value="Jack" v-model="checkedNames">
  <label for="jack">Jack</label>
  <input type="checkbox" id="john" value="John" v-model="checkedNames">
  <label for="john">John</label>
  <input type="checkbox" id="mike" value="Mike" v-model="checkedNames">
  <label for="mike">Mike</label>
  <br>
  <span>Checked names: {{ checkedNames }}</span>
</div>

......

new Vue({
  el: '#example-3',
  data: {
    checkedNames: []
  }
})
单选框
<div id="example-4">
  <input type="radio" id="one" value="One" v-model="picked">
  <label for="one">One</label>
  <br>
  <input type="radio" id="two" value="Two" v-model="picked">
  <label for="two">Two</label>
  <br>
  <span>Picked: {{ picked }}</span>
</div>

......
new Vue({
  el: '#example-4',
  data: {
    picked: ''
  }
})
下拉框
<div id="example-5">
  <select v-model="selected">
    <option disabled value="">请选择</option>
    <option>A</option>
    <option>B</option>
    <option>C</option>
  </select>
  <span>Selected: {{ selected }}</span>
</div>
......

new Vue({
  el: '...',
  data: {
    selected:''
  }
})

计算属性

模板内的表达式非常便利，但是设计它们的初衷是用于简单运算的。在模板中放入太多的逻辑会让模板过重且难以维护。例如：

<div id="example">
  {{ message.split('').reverse().join('') }}
</div>

这个表达式的功能是将message字符串进行反转，这种带有复杂逻辑的表达式，我们可以使用计算属性

<div id="example">
  <p>Original message: "{{ message }}"</p>
  <p>Computed reversed message: "{{ reversedMessage }}"</p>
</div>

......

var vm = new Vue({
  el: '#example',
  data: {
    message: 'Hello'
  },
  computed: {
    // 计算属性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 实例
      return this.message.split('').reverse().join('')
    }
  }
})

侦听属性

侦听属性的作用是侦听某属性值的变化，从而做相应的操作，侦听属性是一个对象，它的键是要监听的对象或者变量，值一般是函数，当你侦听的元素发生变化时，需要执行的函数，这个函数有两个形参，第一个是当前值，第二个是变化后的值。

window.onload = function(){
    var vm = new Vue({
        el:'#app',
        data:{
            iNum:1
        },
        watch:{
            iNum:function(newval,oldval){
                console.log(newval + ' | ' + oldval) 
            }
        },
        methods:{
            fnAdd:function(){
                this.iNum += 1;
            }
        }
    });
}

过滤器

Vue.js 允许你自定义过滤器，可被用于一些常见的文本格式化。过滤器可以用在两个地方：双花括号插值和 v-bind 表达式

<!-- 在双花括号中 -->
{{ prize | RMB }}

<!-- 在v-bind中 -->
<div v-bind:id="rawId | formatId"></div>

过滤器实际上是一个函数，可以在一个组件的选项中定义组件内部过滤器：

data:{
    prize:100
},
filters:{
    RMB:function(value){
        if(value==''){
          return;
        }
        return '¥ '+value;
    }
}

或者在创建 Vue 实例之前全局定义过滤器：

Vue.filter('Yuan',function(value){
    if(value==''){
        return;
    }
    return value+'元';
});

此时过滤器’RMB’只能在定义它的对象接管标签内使用，而’Yuan’可以全局使用

实例生命周期

每个 Vue 实例在被创建时都要经过一系列的初始化过程——例如，需要设置数据监听、编译模板、将实例挂载到 DOM 并在数据变化时更新 DOM 等。
同时在这个过程中会自动运行一些叫做生命周期钩子的函数，我们可以使用这些函数，在实例的不同阶段加上我们需要的代码，实现特定的功能。

beforeCreate
在实例初始化之后，数据观测 (data observer) 和 event/watcher 事件配置之前被调用。
created
在实例创建完成后被立即调用。在这一步，实例已完成以下的配置：数据观测 (data observer)，属性和方法的运算，watch/event 事件回调。然而，挂载阶段还没开始
beforeMount
在挂载开始之前被调用：相关的 render 函数首次被调用。
mounted
实例挂载到dom之后被调用，可以当成是vue对象的ready方法来使用，一般用它来做dom的初始化操作。
beforeUpdate
数据发生变化前调用
updated
数据发生变化后调用

生命周期图示

数据交互

vue.js 没有集成 ajax 功能，要使用 ajax 功能，可以使用 vue 官方推荐的 axios.js 库来做 ajax 的交互。 axios 库的下载地址：https://github.com/axios/axios/releases

axios 完整写法：

axios({
  method: 'post',
  url: '/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});

axios 请求的写法也写成 get 方式后 post 方式。

执行 get 请求
// 为给定 ID 的 user 创建请求
// then是请求成功时的响应，catch是请求失败时的响应

axios.get('/user?ID=12345')
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});


// 可选地，上面的请求可以这样做
axios.get('/user', {
  params: {
    ID: 12345
  }
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});
执行 post 请求
axios.post('/user', {
  firstName: 'Fred',
  lastName: 'Flintstone'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});
-------------本文结束感谢您的阅读-------------

本文标题:Vue.js 笔记

文章作者:曹永林

发布时间:2018年08月08日 - 09:08

最后更新:2018年08月13日 - 18:08

原始链接:http://jovelin.cn/2018/08/08/Vue.js 笔记/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。